<!DOCTYPE html>
<html lang="en">

<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Document</title>
</head>

<body>
  <script>
    // console.log(12);
    // function map(f,a){
    //   const result=new Array(a.length)
    //   for(let i=0;i<a.length;i++){
    //     result[i]=f(a[i])

    //   }
    //   return result
    // }
    // const cube=function(x){
    //   return x*x*x
    // }
    // const num=[0,1,5,10]
    // console.log()

    // 嵌套函数
    /*  function fun1() {
       const num1 = 1
       const num2 = 2
       function fun2() {
         return `这个函数是${num1}`
       }
       return fun2()
     }
     console.log(fun1()); */

    /*   let num=1
      while(num<10){
        num++
        console.log(num);
      } */


    /*   function loop(x){
        if(x>=10){
          return
        }
        // 递归调用
        loop(x+1)
      }
      loop(0) */

    // 函数栈
    /*   function foo(i){
        if(i<0){
          return
        }
        console.log(i);
        foo(i-1)
      }
      foo(3) */

    // 嵌套函数
    /*  function out(a, b) {
       function ins(x) {
         return x * x
       }
       return ins(a) + ins(b)

     }
     console.log(out(1, 3)); */

    // 调用外部函数并为外部函数和内部函数指定参数
    /*   function out(x) {
        function ins(y) {
          return x + y
        }
        return ins
      }
      const fnIns=out(3)
      console.log(fnIns(4));
      console.log(out(3)(4)) */


    // 多层嵌套函数
    /*   function A(x) {
        function B(y) {
          function C(z) {
            console.log(x + y + z);
          }
          C(4)
        }
        B(3)
      }
      A(2) */

    // 命名冲突
    /*  function out() {
       const x = 1
       function ins(x) {
         return x * 4
       }
       return ins
     }
     console.log(out()(10));//40 */


    // 闭包
    /*  const pet=function(name){
       // 外部函数定义了一个名为’name'的变量
       const getName=function(){
         //内部函数可以访问外部函数的'name'变量
         return name
       }
       return getName//返回内部函数，从而将其暴露给外部作用域
     }
     const myPet=pet("vid")
     console.log(myPet());//vid */

    // 返回包含用于操作外部函数的内部变量的方法的对象
    /*  const A = function (name) {
       let sex;
       const B = {
         setName()
       }
     }
  */

    // arguments对象
    /*   function fun(a){
        let result=''
        for(var i=0;i<arguments.length;i++){
          result+=arguments[i]+a
        }
        return result
      }
      console.log(fun("、", "红", "橙", "蓝"));
      // "红、橙、蓝、" */

    // 函数参数
    /*   function fn(a,b){
        b=b!==undefined?b:1
        return a+b
      }
      console.log(fn(5));//6 */

    // 已经定义了b的参数为1
    /*  function fn(a, b = 1) {
       return a + b
     }
     console.log(fn(6)) */

    // 箭头函数
    /*  const a=["a","ab","abc"]
     const a1=a.map(function(s){
       return s.length
     })
     console.log(a1);
     const a2=a.map((s)=>s.length)
     console.log(a2) */

    // 无单独的this
/*     function fn() {
      const self = this
      self.age = 0
      setInterval(function fn1() {
        self.age++
      }, 1000)
    } */
    
    // 箭头函数
  /*   setInterval(()=>{
      this.age++
    },1000) */
  </script>
</body>

</html>